/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package terracraft.world;

import org.newdawn.slick.Graphics;
import terracraft.GameError;
import terracraft.blocs.Bloc;

/**
 * Cette classe représente un morceau de monde de 64x64 blocs.
 * 
 * @author linkpy
 */
public class Morceau {
    // +------------------------------------------------------+
    // |    Champs public static                              |
    // +------------------------------------------------------+
    
    /** Largeur d'un morceau. */
    public static final int LARGEUR = 64;
    /** Hauteur d'un morceau. */
    public static final int HAUTEUR = LARGEUR;

    // +------------------------------------------------------+
    // |    Champs private/protected static                   |
    // +------------------------------------------------------+

    // Aucun champs

    // +------------------------------------------------------+
    // |    Champs public                                     |
    // +------------------------------------------------------+

    // Aucun champs

    // +------------------------------------------------------+
    // |    Champs private                                    |
    // +------------------------------------------------------+

    /** Monde dans lequel le morceau est. */
    private Monde monde;
    
    /** Position X, Y du morceau dans le monde. */
    private int x, y;

    /** Liste des blocs du morceau */
    private int blocs[][];
    
    // +------------------------------------------------------+
    // |    Champs protected                                  |
    // +------------------------------------------------------+

    // Aucun champs

    // +------------------------------------------------------+
    // |    Méthodes public static                            |
    // +------------------------------------------------------+

    // Aucun méthodes

    // +------------------------------------------------------+
    // |    Méthodes private/protected static                 |
    // +------------------------------------------------------+

    // Aucune méthodes

    // +------------------------------------------------------+
    // |    Constructeur public                               |
    // +------------------------------------------------------+

    /**
     * Constructeur avec la position X, Y, et le monde où il est.
     * 
     * @param x La position X
     * @param y La position Y
     * @param monde Le monde où il est
     */
    public Morceau(int x, int y, Monde monde) {
        if(y < 0)
            throw new GameError("Morceau", "Création avec l'axe Y négatif.");
        
        this.x = x;
        this.y = y;
        
        this.monde = monde;
        
        blocs = new int[LARGEUR][HAUTEUR];
        
        for(int xx = 0; xx < LARGEUR; xx++) {
            for(int yy = 0; yy < HAUTEUR; yy++) {
                blocs[xx][yy] = Bloc.air.avoirID();
            }
        }
    }

    // +------------------------------------------------------+
    // |    Constructeur private/protected                    |
    // +------------------------------------------------------+

    // Aucun constructeur

    // +------------------------------------------------------+
    // |    Méthodes public                                   |
    // +------------------------------------------------------+

    /**
     * Récupère le monde où est le morceau.
     * 
     * @return Le monde où est le morceau
     */
    public Monde avoirMonde() {
        return monde;
    }
    
    /**
     * Récupère la position X.
     * 
     * @return La position X
     */
    public int avoirX() {
        return x;
    }
    
    /**
     * Récupère la position Y.
     * 
     * @return La position Y
     */
    public int avoirY() {
        return y;
    }
    
    /**
     * Récupère le bloc en X, Y.
     * 
     * @param x La position X du bloc
     * @param y La position Y du bloc
     * @return Le bloc en X, Y
     */
    public int avoirBloc(int x, int y) {
        if(x < 0 || y < 0 || x > LARGEUR - 1 || y > HAUTEUR - 1)
            return Bloc.air.avoirID();
        
        return blocs[x][y];
    }
    
    /**
     * Défini le bloc en X, Y
     * 
     * @param x La position X du bloc
     * @param y La position Y du bloc
     * @param id L'ID du bloc nouveau bloc
     */
    public void definirBloc(int x, int y, int id) {
        if(x < 0 || y < 0 || x > LARGEUR - 1 || y > HAUTEUR - 1)
            return;
        
        blocs[x][y] = id;
    }
    
    /**
     * Affiche le morceau en X, Y en utilisant G.
     * 
     * @param x La position X
     * @param y La position Y
     * @param g L'afficheur utilisé
     */
    public void afficher(int x, int y, Graphics g) {
        g.translate(x, y);
        
        for(int xx = 0; x < LARGEUR; x++) {
            for(int yy = 0; yy < HAUTEUR; yy++) {
                g.pushTransform();
                
                Bloc.avoirBlocAvecID(blocs[xx][yy]).afficher(xx*Bloc.LARGEUR, 
                        yy*Bloc.HAUTEUR, g);
                
                g.popTransform();
            }
        }
    }
    
    // +------------------------------------------------------+
    // |    Méthodes abstract                                 |
    // +------------------------------------------------------+

    // Aucune méthodes
}
